/**
 * 框架通信SDK - 用于PWA主框架与插件页面之间的通信
 * 提供统一的消息发送和接收机制，处理主题、语言等全局设置
 */
(function(window) {
    'use strict';
    
    // SDK配置
    const SDK_CONFIG = {
        // 消息类型定义
        MESSAGE_TYPES: {
            SETTINGS_UPDATE: 'SETTINGS_UPDATE',
            THEME_CHANGE: 'THEME_CHANGE',
            LANGUAGE_CHANGE: 'LANGUAGE_CHANGE',
            UPDATE_TITLE: 'UPDATE_TITLE',
            REQUEST_SETTINGS: 'REQUEST_SETTINGS',
            ACTION_PERFORMED: 'ACTION_PERFORMED'
        },
        
        // 默认设置
        DEFAULT_SETTINGS: {
            theme: 'light',
            language: 'zh-CN',
            fontSize: 'medium'
        }
    };
    
    // 等待i18n模块加载完成
    function waitForI18n() {
        return new Promise((resolve) => {
            const checkI18n = () => {
                if (window.i18n) {
                    resolve();
                } else {
                    setTimeout(checkI18n, 50);
                }
            };
            checkI18n();
        });
    };
    
    /**
     * 框架通信SDK类
     * @class FrameSDK
     */
    class FrameSDK {
        /**
         * 构造函数
         * @param {Object} options - 配置选项
         * @param {boolean} options.isMainFrame - 是否为主框架
         * @param {Function} options.onSettingsUpdate - 设置更新回调函数
         */
        constructor(options = {}) {
            this.isMainFrame = options.isMainFrame || false;
            this.currentSettings = { ...SDK_CONFIG.DEFAULT_SETTINGS };
            this.listeners = {};
            this.onSettingsUpdate = options.onSettingsUpdate;
            
            // 初始化消息监听器
            this.setupI18n();
            // 注意：不在这里调用init()，避免循环依赖
        }
        
        /**
         * 初始化SDK
         */
        async init() {
            // 添加消息事件监听器
            window.addEventListener('message', this.handleMessage.bind(this));
            
            // 等待i18n加载并应用语言设置
            await waitForI18n();
            if (window.i18n) {
                window.i18n.setLanguage(this.currentSettings.language);
                // 自动更新页面元素
                window.i18n.updateAllElements();
            }
            
            // 如果是插件页面，自动请求设置
            if (!this.isMainFrame) {
                this.requestSettings();
            }
        }
        
        /**
         * 处理接收到的消息
         * @param {MessageEvent} event - 消息事件对象
         */
        handleMessage(event) {
            const { data } = event;
            
            if (!data || !data.type) return;
            
            const { type, ...payload } = data;
            
            // 处理内置消息类型
            switch (type) {
                case SDK_CONFIG.MESSAGE_TYPES.SETTINGS_UPDATE:
                    this.handleSettingsUpdate(payload);
                    break;
                    
                case SDK_CONFIG.MESSAGE_TYPES.THEME_CHANGE:
                    this.handleThemeChange(payload.theme);
                    break;
                    
                case SDK_CONFIG.MESSAGE_TYPES.LANGUAGE_CHANGE:
                    this.handleLanguageChange(payload.language);
                    break;
                    
                case SDK_CONFIG.MESSAGE_TYPES.UPDATE_TITLE:
                    this.handleUpdateTitle(payload.title);
                    break;
                    
                case SDK_CONFIG.MESSAGE_TYPES.REQUEST_SETTINGS:
                    this.handleRequestSettings(event.source);
                    break;
                    
                default:
                    // 触发自定义监听器
                    this.triggerListener(type, payload);
            }
        }
        
        /**
         * 处理设置更新
         * @param {Object} settings - 新的设置对象
         */
        handleSettingsUpdate(settings) {
            this.currentSettings = { ...this.currentSettings, ...settings };
            
            // 应用主题（适用于所有框架）
            document.body.classList.toggle('dark-theme', this.currentSettings.theme === 'dark');
            
            // 应用语言设置（适用于所有框架）
            this.applyLanguage(this.currentSettings.language);
            
            // 如果不是主框架，调用外部设置更新回调
            if (!this.isMainFrame) {
                if (typeof this.onSettingsUpdate === 'function') {
                    this.onSettingsUpdate(this.currentSettings);
                }
            }
            
            // 触发设置更新事件
            this.triggerListener('settingsUpdated', this.currentSettings);
        }
        
        /**
         * 设置i18n集成
         */
        setupI18n() {
            waitForI18n().then(() => {
                if (window.i18n) {
                    window.i18n.setLanguage(this.currentSettings.language);
                }
            });
        }
        
        /**
         * 应用语言设置
         * @param {string} language - 语言代码
         */
        applyLanguage(language) {
            if (window.i18n) {
                window.i18n.setLanguage(language);
                window.i18n.updateAllElements();
            }
        }
        
        /**
         * 处理主题变更
         * @param {string} theme - 新主题 ('light' 或 'dark')
         */
        handleThemeChange(theme) {
            if (this.isMainFrame) {
                // 主框架处理主题变更并广播给所有页面
                this.currentSettings.theme = theme;
                this.broadcastSettings();
            } else {
                // 插件页面接收到主题变更，直接应用
                document.body.classList.toggle('dark-theme', theme === 'dark');
                this.currentSettings.theme = theme;
            }
        }
        
        /**
         * 处理语言变更
         * @param {string} language - 新语言 ('zh-CN' 或 'en-US')
         */
        handleLanguageChange(language) {
            if (this.isMainFrame) {
                // 主框架处理语言变更并广播给所有页面
                this.currentSettings.language = language;
                
                // 立即应用语言设置并更新主框架UI
                this.applyLanguage(language);
                
                this.broadcastSettings();
            } else {
                // 插件页面接收到语言变更
                this.currentSettings.language = language;
                
                // 应用语言设置
                this.applyLanguage(language);
                
                // 调用外部设置更新回调
                if (typeof this.onSettingsUpdate === 'function') {
                    this.onSettingsUpdate(this.currentSettings);
                }
            }
        }
        
        /**
         * 处理标题更新
         * @param {string} title - 新标题
         */
        handleUpdateTitle(title) {
            if (this.isMainFrame) {
                console.log('更新标题:', title);
                // 同时更新浏览器标题和页面内标题
                document.title = title + ' - VR-IoT';
                
                // 主框架更新页面内标题
                const headerTitle = document.querySelector('.app-header h1');
                if (headerTitle) {
                    headerTitle.textContent = title;
                }
            }
        }
        
        /**
         * 处理设置请求
         * @param {Window} source - 消息源窗口
         */
        handleRequestSettings(source) {
            if (this.isMainFrame) {
                // 主框架发送当前设置给请求的页面
                this.sendMessage(source, SDK_CONFIG.MESSAGE_TYPES.SETTINGS_UPDATE, this.currentSettings);
            }
        }
        
        /**
         * 发送消息
         * @param {Window} target - 目标窗口
         * @param {string} type - 消息类型
         * @param {Object} data - 消息数据
         */
        sendMessage(target, type, data = {}) {
            target.postMessage({ type, ...data }, '*');
        }
        
        /**
         * 发送消息给父窗口（用于插件页面）
         * @param {string} type - 消息类型
         * @param {Object} data - 消息数据
         */
        sendToParent(type, data = {}) {
            if (window.parent && window.parent !== window) {
                this.sendMessage(window.parent, type, data);
            }
        }
        
        /**
         * 添加子框架（用于主框架）
         * @param {HTMLIFrameElement} iframe - iframe元素
         */
        addChildFrame(iframe) {
            if (this.isMainFrame && iframe && iframe.contentWindow) {
                console.log('添加子框架并发送设置:', iframe.src);
                // 向子框架发送当前设置
                this.sendMessage(iframe.contentWindow, SDK_CONFIG.MESSAGE_TYPES.SETTINGS_UPDATE, this.currentSettings);
            }
        }
        
        /**
         * 广播设置给所有子窗口（用于主框架）
         */
        broadcastSettings() {
            if (this.isMainFrame) {
                const frames = document.querySelectorAll('iframe');
                frames.forEach(frame => {
                    if (frame.contentWindow) {
                        this.sendMessage(frame.contentWindow, SDK_CONFIG.MESSAGE_TYPES.SETTINGS_UPDATE, this.currentSettings);
                    }
                });
            }
        }
        
        /**
         * 请求设置（用于插件页面）
         */
        requestSettings() {
            if (!this.isMainFrame) {
                this.sendToParent(SDK_CONFIG.MESSAGE_TYPES.REQUEST_SETTINGS);
            }
        }
        
        /**
         * 发送标题更新（用于插件页面）
         * @param {string} title - 新标题
         */
        updateTitle(title) {
            if (!this.isMainFrame) {
                this.sendToParent(SDK_CONFIG.MESSAGE_TYPES.UPDATE_TITLE, { title });
            }
        }
        
        /**
         * 切换主题（用于设置页面）
         * @param {string} theme - 新主题 ('light' 或 'dark')
         */
        changeTheme(theme) {
            console.log('changeTheme', theme);
            this.sendToParent(SDK_CONFIG.MESSAGE_TYPES.THEME_CHANGE, { theme });
        }
        
        /**
         * 切换语言（用于设置页面）
         * @param {string} language - 新语言 ('zh-CN' 或 'en-US')
         */
        changeLanguage(language) {
            // 应用语言设置
            this.applyLanguage(language);
            
            this.sendToParent(SDK_CONFIG.MESSAGE_TYPES.LANGUAGE_CHANGE, { language });
        }
        
        /**
         * 获取当前设置
         * @returns {Object} 当前设置对象
         */
        getSettings() {
            return { ...this.currentSettings };
        }
        
        /**
         * 注册消息监听器
         * @param {string} eventType - 事件类型
         * @param {Function} callback - 回调函数
         */
        on(eventType, callback) {
            if (!this.listeners[eventType]) {
                this.listeners[eventType] = [];
            }
            this.listeners[eventType].push(callback);
        }
        
        /**
         * 移除消息监听器
         * @param {string} eventType - 事件类型
         * @param {Function} callback - 回调函数（可选，不传则移除所有该类型监听器）
         */
        off(eventType, callback) {
            if (!this.listeners[eventType]) return;
            
            if (callback) {
                this.listeners[eventType] = this.listeners[eventType].filter(cb => cb !== callback);
            } else {
                delete this.listeners[eventType];
            }
        }
        
        /**
         * 触发监听器
         * @param {string} eventType - 事件类型
         * @param {*} data - 事件数据
         */
        triggerListener(eventType, data) {
            if (!this.listeners[eventType]) return;
            
            this.listeners[eventType].forEach(callback => {
                try {
                    callback(data);
                } catch (error) {
                    console.error(`Error in ${eventType} listener:`, error);
                }
            });
        }
        
        /**
         * 销毁SDK实例
         */
        destroy() {
            window.removeEventListener('message', this.handleMessage.bind(this));
            this.listeners = {};
        }
    }
    
    // 导出SDK
    window.FrameSDK = FrameSDK;
    window.FrameSDK_CONFIG = SDK_CONFIG;
    
    // 创建默认实例
    window.frameSDK = new FrameSDK({ isMainFrame: false });
    
    // 提供自动初始化功能
    document.addEventListener('DOMContentLoaded', () => {
        // 检查是否需要自动初始化
        if (document.querySelector('[data-auto-init-sdk]')) {
            // 自动初始化并请求设置
            window.frameSDK.init().then(() => {
                // 请求设置后立即应用
                window.frameSDK.requestSettings();
            });
        }
    });
    
})(window);